Análise dos dados de Covid-19 no Brasil¶
Autor: Leonardo Simões
1. Introdução¶
Este é um projeto guiado da Digital Innovation One: "Criando modelos com Python e Machine Learning para prever a evolução do COVID-19 no Brasil". O objetivo é analisar os dados das séries temporais e usar algum modelo ARIMA para predição.
Os dados usados foram obtidos na plataforma do Kaggle: https://www.kaggle.com/datasets/sudalairajkumar/novel-corona-virus-2019-dataset
2. Preparação dos dados¶
Na etapa de preparação dos dados são realizadas algumas operações que precedem a análise dos dados:
- Importe de bibliotecas
- Carregamento dos dados em um dataframe
- Definições de formatação
- Separação e transformações das séries
- Definições de funções
In [1]:
# Imports das bibliotecas mais usadas
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
In [2]:
# Imports da biblioteca Plotly
import plotly
import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots
In [3]:
# Imports das bibliotecas para séries temporais
from datetime import datetime
from statsmodels.tsa.seasonal import seasonal_decompose
from statsmodels.tsa.stattools import adfuller
from pmdarima.arima import auto_arima
import joblib
In [4]:
# Definições de formatação de números decimais
pd.options.display.float_format = '{:20,.2f}'.format
np.set_printoptions(precision=2)
In [5]:
# Definição da função load_df_temporal_series()
def load_df_temporal_series(diretorio_do_arquivo):
"""
Carrega os dados em um dataframe.
Renomeia as colunas do dataframe.
Remove linhas duplicadas no dataframe.
Ordena os valores por 'Data'.
Retorna um DataFrame
Argumento:
diretorio_do_arquivo -- o diretório do arquivo arquivo de csv.
"""
dateparse = lambda x: datetime.strptime(x, '%m/%d/%Y')
colunas_usadas = ['ObservationDate', 'Country/Region', 'Confirmed','Deaths','Recovered']
df = pd.read_csv(diretorio_do_arquivo, usecols=colunas_usadas, parse_dates=['ObservationDate'], date_parser=dateparse)
colunas_renomeadas = {'ObservationDate':'Data', 'Country/Region':'Pais', 'Confirmed':'Casos',
'Deaths':'Mortes', 'Recovered':'Recuperados'}
df.rename(columns=colunas_renomeadas, inplace=True)
df.drop_duplicates(keep='first', inplace=True)
df.sort_values(by=['Data'], inplace=True)
return df
In [6]:
# Definição da função somar_agrupamento()
def somar_agrupamento(df, colunas_agrupamento, colunas_soma):
"""
Retorna um dataframe de soma por grupo.
Argumentos:
df -- DataFrame
colunas_agrupamento -- list
colunas_soma -- list
"""
df_agrupado = df.groupby(colunas_agrupamento, as_index=False)
df_soma = df_agrupado[colunas_soma].sum()
return df_soma
In [7]:
# Definição da função mesclar_colunas()
def mesclar_colunas(df, colunas_id, colunas_valores, nome_variavel = 'Variavel', nome_value = 'Valor'):
"""
Retorna um dataframe mesclado.
Argumentos:
df -- DataFrame
colunas_id -- list
colunas_valores -- list
nome_variavel -- string (Opcional - Valor padrão é 'Variavel')
nome_value -- string (Opcional - Valor padrão é 'Valor')
"""
df_m = pd.melt(df, id_vars=colunas_id, value_vars=colunas_valores)
df_m.rename(columns={'variable':nome_variavel, 'value':nome_value}, inplace=True)
return df_m
In [8]:
# Definição da função plotar_linha()
def plotar_linha(df, eixo_x, eixo_y='Quantidade', titulo='Titulo', categorias=None):
"""
Plota um gráfico de linhas.
Argumentos:
df -- DataFrame
eixo_x -- string
eixo_y -- string (Opcional - Valor padrão é 'Quantidade')
titulo -- string (Opcional - Valor padrão é 'Titulo')
categorias -- string (Opcional - Valor padrão é None)
"""
fig = px.line(df, x=eixo_x, y=eixo_y,
color=categorias
)
fig.update_layout(title_text=titulo, title_x=0.5,
legend=dict(yanchor="top", y=0.99, xanchor="left", x=0.01)
)
fig.show()
In [9]:
# Definição da função plotar_componentes_serie()
def plotar_componentes_serie(serie):
"""
Plota gráficos da série e de suas componentes.
Argumentos:
serie -- Serie
"""
decomposicao = seasonal_decompose(serie)
fig = decomposicao.plot();
fig.set_size_inches((11, 6));
fig.tight_layout();
plt.show();
In [10]:
# Definição da função diferenciar_serie()
def diferenciar_serie(serie):
"""
Retorna uma série diferenciada em um passo.
Argumentos:
serie -- Serie
"""
return serie.diff().dropna()
In [11]:
# Definição da função salvar_modelo_arquivo()
def salvar_modelo_arquivo(modelo, nome_arquivo='ModeloARIMA'):
"""
Salvar um modelo em um arquivo .pkl
Argumentos:
modelo -- model ARIMA
nome_arquivo -- string (Opcional - Valor padrão é 'ModeloARIMA')
"""
nome_arquivo = nome_arquivo + '.pkl'
joblib.dump(modelo, nome_arquivo)
In [12]:
# Diretório do arquivo de dados
ARQUIVO = './data/covid_19_data.csv'
In [13]:
df = load_df_temporal_series(ARQUIVO)
df.head()
Out[13]:
In [14]:
df_soma_mundo = somar_agrupamento(df, colunas_agrupamento=['Data'], colunas_soma=['Casos','Mortes','Recuperados'])
df_soma_mundo.head()
Out[14]:
In [15]:
df_brasil = df.loc[(df['Pais'] == 'Brazil') & (df['Data'] >= '2020-02-26')]
df_brasil.head()
Out[15]:
In [16]:
df_soma_brasil = somar_agrupamento(df_brasil, colunas_agrupamento=['Data'], colunas_soma=['Casos','Mortes','Recuperados'])
df_soma_brasil.tail()
Out[16]:
In [17]:
df_melt_br = mesclar_colunas(df_soma_brasil, colunas_id=['Data'], colunas_valores=['Casos', 'Mortes', 'Recuperados'], nome_variavel='Tipo', nome_value='Quantidade')
df_melt_br.head()
Out[17]:
In [18]:
df_melt_mundo = mesclar_colunas(df_soma_mundo, colunas_id=['Data'], colunas_valores=['Casos', 'Mortes', 'Recuperados'], nome_variavel='Tipo', nome_value='Quantidade')
df_melt_mundo.head()
Out[18]:
In [19]:
casos_br = df_soma_brasil.set_index('Data')['Casos']
novos_casos_br = diferenciar_serie(casos_br)
novos_casos_br.head()
Out[19]:
In [20]:
plotar_linha(df_melt_br, eixo_x='Data', eixo_y='Quantidade', titulo='COVID no Brasil', categorias='Tipo')
In [21]:
plotar_linha(df_melt_mundo, eixo_x='Data', eixo_y='Quantidade', titulo='COVID no Mundo', categorias='Tipo')
In [22]:
# Definindo 'Data' como index
df_soma_brasil.set_index('Data', inplace=True)
df_soma_brasil.head()
Out[22]:
In [23]:
df_soma_mundo.describe()
Out[23]:
In [24]:
df_soma_brasil.describe()
Out[24]:
In [25]:
plotar_componentes_serie(df_soma_brasil['Casos'])
In [26]:
plotar_componentes_serie(df_soma_brasil['Mortes'])
In [27]:
plotar_componentes_serie(df_soma_brasil['Recuperados'])
In [28]:
plotar_componentes_serie(novos_casos_br)
4. Estimativa¶
Nesta etapa é treinado um modelo para prever novos casos de Covid no Brasil usandos os dados passados.
4.1.Treinamento do modelo¶
In [29]:
modelo = auto_arima(novos_casos_br)
modelo
Out[29]:
In [30]:
modelo.summary()
Out[30]:
O modelo obtido foi:
$$ARIMA(5,1,2) y_t = \sum_{i=1}^5 a_iy_{t-i} + \sum_{j=1}^2 m_j\epsilon_{t-j} + \epsilon_t$$$$ARIMA(5,1,2) y_t = 0.0505y_{t-1} - 0.5355y_{t-2} - 0.4052y_{t-3} - 0.3912y_{t-4} - 0.4873y_{t-5} -0.9754\epsilon_{t-1} + 0.6754\epsilon_{t-2} + \epsilon_t$$In [31]:
modelo.plot_diagnostics(figsize=(13, 9));
In [32]:
novos_casos_preditos = modelo.predict(n_periods=30)
novos_casos_preditos= novos_casos_preditos.to_frame().reset_index()
novos_casos_preditos.rename(columns={'index': 'Data', 0:'Casos'}, inplace=True)
novos_casos_preditos['Tipo'] = 'Predito'
novos_casos_preditos.tail()
Out[32]:
In [33]:
novos_casos_parcela = novos_casos_br[-200:].copy()
#novos_casos_parcela = df_soma_brasil['Casos'][-200:].copy()
novos_casos_br = diferenciar_serie(casos_br)
novos_casos_parcela = novos_casos_parcela.to_frame().reset_index()
#novos_casos_parcela.rename(columns={'index': 'Data', 0:'Casos'}, inplace=True)
novos_casos_parcela['Tipo'] = 'Real'
novos_casos_parcela.tail()
Out[33]:
In [34]:
df_novos_casos = pd.concat([novos_casos_parcela, novos_casos_preditos])
In [35]:
titulo_pred = 'Números de novos casos de Covid no Brasil (Real X Predito)'
plotar_linha(df_novos_casos, eixo_x='Data', eixo_y='Casos', titulo=titulo_pred, categorias='Tipo')
In [36]:
salvar_modelo_arquivo(modelo, nome_arquivo='Modelo_ARIMA-Covid-Brasil')
Referências¶
DIO (Digital Innovation One): Criando modelos com Python e Machine Learning para prever a evolução do COVID-19 no Brasil
KAGGLE - Novel Corona Virus 2019 Dataset: https://www.kaggle.com/datasets/sudalairajkumar/novel-corona-virus-2019-dataset
TOWARDS DATA SCIENCE - Time Series forecasting using Auto ARIMA in python: https://towardsdatascience.com/time-series-forecasting-using-auto-arima-in-python-bb83e49210cd